// $ANTLR 3.5 /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g 2013-10-21 19:15:11

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.debug.*;
import java.io.IOException;
@SuppressWarnings("all")
public class MiniPParser extends DebugParser {
	public static final String[] tokenNames = new String[] {
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "BOOL", "COMMENT", "DECLA", "ESC_SEQ", 
		"ID", "LINEOP", "NUMBER", "PCLOSED", "POINTOP", "POPEN", "RELOP", "SEMI", 
		"'\"'", "','", "'.'", "'\\\\'", "'begin'", "'boolean'", "'do'", "'else'", 
		"'end'", "'fi'", "'if'", "'integer'", "'od'", "'println'", "'program'", 
		"'read'", "'real'", "'string'", "'then'", "'while'"
	};
	public static final int EOF=-1;
	public static final int T__16=16;
	public static final int T__17=17;
	public static final int T__18=18;
	public static final int T__19=19;
	public static final int T__20=20;
	public static final int T__21=21;
	public static final int T__22=22;
	public static final int T__23=23;
	public static final int T__24=24;
	public static final int T__25=25;
	public static final int T__26=26;
	public static final int T__27=27;
	public static final int T__28=28;
	public static final int T__29=29;
	public static final int T__30=30;
	public static final int T__31=31;
	public static final int T__32=32;
	public static final int T__33=33;
	public static final int T__34=34;
	public static final int T__35=35;
	public static final int BOOL=4;
	public static final int COMMENT=5;
	public static final int DECLA=6;
	public static final int ESC_SEQ=7;
	public static final int ID=8;
	public static final int LINEOP=9;
	public static final int NUMBER=10;
	public static final int PCLOSED=11;
	public static final int POINTOP=12;
	public static final int POPEN=13;
	public static final int RELOP=14;
	public static final int SEMI=15;

	// delegates
	public Parser[] getDelegates() {
		return new Parser[] {};
	}

	// delegators


	public static final String[] ruleNames = new String[] {
		"invalidRule", "atom", "arithExpr", "ifStat", "printStat", "whileStat", 
		"prog", "constant", "statement", "realConst", "intConst", "stringConst", 
		"declaration", "readStat", "comparison", "pointExpr", "assignment"
	};

	public static final boolean[] decisionCanBacktrack = new boolean[] {
		false, // invalid decision
		false, false, false, false, false, false, false, false, false, false, 
		    false, false, false, false, false, false, false, false
	};

 
	public int ruleLevel = 0;
	public int getRuleLevel() { return ruleLevel; }
	public void incRuleLevel() { ruleLevel++; }
	public void decRuleLevel() { ruleLevel--; }
	public MiniPParser(TokenStream input) {
		this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
	}
	public MiniPParser(TokenStream input, int port, RecognizerSharedState state) {
		super(input, state);
		DebugEventSocketProxy proxy =
			new DebugEventSocketProxy(this, port, null);

		setDebugListener(proxy);
		try {
			proxy.handshake();
		}
		catch (IOException ioe) {
			reportError(ioe);
		}
	}

	public MiniPParser(TokenStream input, DebugEventListener dbg) {
		super(input, dbg, new RecognizerSharedState());
	}

	protected boolean evalPredicate(boolean result, String predicate) {
		dbg.semanticPredicate(result, predicate);
		return result;
	}

	@Override public String[] getTokenNames() { return MiniPParser.tokenNames; }
	@Override public String getGrammarFileName() { return "/Users/iamapo/Downloads/CI Praktikum 1/MiniP.g"; }



	// $ANTLR start "prog"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:4:1: prog : 'program' ( declaration )* 'begin' ( statement )* 'end' ;
	public final void prog() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "prog");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(4, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:4:7: ( 'program' ( declaration )* 'begin' ( statement )* 'end' )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:4:9: 'program' ( declaration )* 'begin' ( statement )* 'end'
			{
			dbg.location(4,9);
			match(input,30,FOLLOW_30_in_prog12); dbg.location(4,19);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:4:19: ( declaration )*
			try { dbg.enterSubRule(1);

			loop1:
			while (true) {
				int alt1=2;
				try { dbg.enterDecision(1, decisionCanBacktrack[1]);

				int LA1_0 = input.LA(1);
				if ( (LA1_0==21||LA1_0==27||(LA1_0 >= 32 && LA1_0 <= 33)) ) {
					alt1=1;
				}

				} finally {dbg.exitDecision(1);}

				switch (alt1) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:4:19: declaration
					{
					dbg.location(4,19);
					pushFollow(FOLLOW_declaration_in_prog14);
					declaration();
					state._fsp--;

					}
					break;

				default :
					break loop1;
				}
			}
			} finally {dbg.exitSubRule(1);}
			dbg.location(4,32);
			match(input,20,FOLLOW_20_in_prog17); dbg.location(4,40);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:4:40: ( statement )*
			try { dbg.enterSubRule(2);

			loop2:
			while (true) {
				int alt2=2;
				try { dbg.enterDecision(2, decisionCanBacktrack[2]);

				int LA2_0 = input.LA(1);
				if ( (LA2_0==ID||LA2_0==26||LA2_0==29||LA2_0==31||LA2_0==35) ) {
					alt2=1;
				}

				} finally {dbg.exitDecision(2);}

				switch (alt2) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:4:40: statement
					{
					dbg.location(4,40);
					pushFollow(FOLLOW_statement_in_prog19);
					statement();
					state._fsp--;

					}
					break;

				default :
					break loop2;
				}
			}
			} finally {dbg.exitSubRule(2);}
			dbg.location(4,51);
			match(input,24,FOLLOW_24_in_prog22); 
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(4, 56);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "prog");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "prog"



	// $ANTLR start "declaration"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:6:1: declaration : ( 'integer' | 'real' | 'string' | 'boolean' ) ID ( ',' ID )* SEMI ;
	public final void declaration() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "declaration");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(6, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:6:12: ( ( 'integer' | 'real' | 'string' | 'boolean' ) ID ( ',' ID )* SEMI )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:6:14: ( 'integer' | 'real' | 'string' | 'boolean' ) ID ( ',' ID )* SEMI
			{
			dbg.location(6,14);
			if ( input.LA(1)==21||input.LA(1)==27||(input.LA(1) >= 32 && input.LA(1) <= 33) ) {
				input.consume();
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				dbg.recognitionException(mse);
				throw mse;
			}dbg.location(6,52);
			match(input,ID,FOLLOW_ID_in_declaration40); dbg.location(6,54);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:6:54: ( ',' ID )*
			try { dbg.enterSubRule(3);

			loop3:
			while (true) {
				int alt3=2;
				try { dbg.enterDecision(3, decisionCanBacktrack[3]);

				int LA3_0 = input.LA(1);
				if ( (LA3_0==17) ) {
					alt3=1;
				}

				} finally {dbg.exitDecision(3);}

				switch (alt3) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:6:55: ',' ID
					{
					dbg.location(6,55);
					match(input,17,FOLLOW_17_in_declaration42); dbg.location(6,58);
					match(input,ID,FOLLOW_ID_in_declaration43); 
					}
					break;

				default :
					break loop3;
				}
			}
			} finally {dbg.exitSubRule(3);}
			dbg.location(6,63);
			match(input,SEMI,FOLLOW_SEMI_in_declaration47); 
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(6, 66);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "declaration");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "declaration"



	// $ANTLR start "statement"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:8:1: statement : ( assignment | ifStat | whileStat | readStat | printStat );
	public final void statement() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "statement");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(8, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:8:10: ( assignment | ifStat | whileStat | readStat | printStat )
			int alt4=5;
			try { dbg.enterDecision(4, decisionCanBacktrack[4]);

			switch ( input.LA(1) ) {
			case ID:
				{
				alt4=1;
				}
				break;
			case 26:
				{
				alt4=2;
				}
				break;
			case 35:
				{
				alt4=3;
				}
				break;
			case 31:
				{
				alt4=4;
				}
				break;
			case 29:
				{
				alt4=5;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 4, 0, input);
				dbg.recognitionException(nvae);
				throw nvae;
			}
			} finally {dbg.exitDecision(4);}

			switch (alt4) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:8:12: assignment
					{
					dbg.location(8,12);
					pushFollow(FOLLOW_assignment_in_statement54);
					assignment();
					state._fsp--;

					}
					break;
				case 2 :
					dbg.enterAlt(2);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:9:5: ifStat
					{
					dbg.location(9,5);
					pushFollow(FOLLOW_ifStat_in_statement60);
					ifStat();
					state._fsp--;

					}
					break;
				case 3 :
					dbg.enterAlt(3);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:10:12: whileStat
					{
					dbg.location(10,12);
					pushFollow(FOLLOW_whileStat_in_statement73);
					whileStat();
					state._fsp--;

					}
					break;
				case 4 :
					dbg.enterAlt(4);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:11:6: readStat
					{
					dbg.location(11,6);
					pushFollow(FOLLOW_readStat_in_statement80);
					readStat();
					state._fsp--;

					}
					break;
				case 5 :
					dbg.enterAlt(5);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:12:5: printStat
					{
					dbg.location(12,5);
					pushFollow(FOLLOW_printStat_in_statement86);
					printStat();
					state._fsp--;

					}
					break;

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(13, 2);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "statement");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "statement"



	// $ANTLR start "assignment"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:16:1: assignment : ID DECLA ( arithExpr | stringConst | comparison ) ;
	public final void assignment() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "assignment");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(16, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:16:11: ( ID DECLA ( arithExpr | stringConst | comparison ) )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:16:13: ID DECLA ( arithExpr | stringConst | comparison )
			{
			dbg.location(16,13);
			match(input,ID,FOLLOW_ID_in_assignment97); dbg.location(16,16);
			match(input,DECLA,FOLLOW_DECLA_in_assignment99); dbg.location(16,22);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:16:22: ( arithExpr | stringConst | comparison )
			int alt5=3;
			try { dbg.enterSubRule(5);
			try { dbg.enterDecision(5, decisionCanBacktrack[5]);

			try {
				isCyclicDecision = true;
				alt5 = dfa5.predict(input);
			}
			catch (NoViableAltException nvae) {
				dbg.recognitionException(nvae);
				throw nvae;
			}
			} finally {dbg.exitDecision(5);}

			switch (alt5) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:16:23: arithExpr
					{
					dbg.location(16,23);
					pushFollow(FOLLOW_arithExpr_in_assignment102);
					arithExpr();
					state._fsp--;

					}
					break;
				case 2 :
					dbg.enterAlt(2);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:16:33: stringConst
					{
					dbg.location(16,33);
					pushFollow(FOLLOW_stringConst_in_assignment104);
					stringConst();
					state._fsp--;

					}
					break;
				case 3 :
					dbg.enterAlt(3);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:16:45: comparison
					{
					dbg.location(16,45);
					pushFollow(FOLLOW_comparison_in_assignment106);
					comparison();
					state._fsp--;

					}
					break;

			}
			} finally {dbg.exitSubRule(5);}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(16, 55);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "assignment");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "assignment"



	// $ANTLR start "arithExpr"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:17:1: arithExpr : pointExpr ( LINEOP pointExpr )* ;
	public final void arithExpr() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "arithExpr");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(17, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:17:10: ( pointExpr ( LINEOP pointExpr )* )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:17:13: pointExpr ( LINEOP pointExpr )*
			{
			dbg.location(17,13);
			pushFollow(FOLLOW_pointExpr_in_arithExpr114);
			pointExpr();
			state._fsp--;
			dbg.location(17,23);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:17:23: ( LINEOP pointExpr )*
			try { dbg.enterSubRule(6);

			loop6:
			while (true) {
				int alt6=2;
				try { dbg.enterDecision(6, decisionCanBacktrack[6]);

				int LA6_0 = input.LA(1);
				if ( (LA6_0==LINEOP) ) {
					alt6=1;
				}

				} finally {dbg.exitDecision(6);}

				switch (alt6) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:17:24: LINEOP pointExpr
					{
					dbg.location(17,24);
					match(input,LINEOP,FOLLOW_LINEOP_in_arithExpr117); dbg.location(17,31);
					pushFollow(FOLLOW_pointExpr_in_arithExpr119);
					pointExpr();
					state._fsp--;

					}
					break;

				default :
					break loop6;
				}
			}
			} finally {dbg.exitSubRule(6);}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(17, 43);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "arithExpr");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "arithExpr"



	// $ANTLR start "pointExpr"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:18:1: pointExpr : atom ( POINTOP atom )* ;
	public final void pointExpr() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "pointExpr");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(18, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:18:10: ( atom ( POINTOP atom )* )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:18:13: atom ( POINTOP atom )*
			{
			dbg.location(18,13);
			pushFollow(FOLLOW_atom_in_pointExpr130);
			atom();
			state._fsp--;
			dbg.location(18,18);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:18:18: ( POINTOP atom )*
			try { dbg.enterSubRule(7);

			loop7:
			while (true) {
				int alt7=2;
				try { dbg.enterDecision(7, decisionCanBacktrack[7]);

				int LA7_0 = input.LA(1);
				if ( (LA7_0==POINTOP) ) {
					alt7=1;
				}

				} finally {dbg.exitDecision(7);}

				switch (alt7) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:18:19: POINTOP atom
					{
					dbg.location(18,19);
					match(input,POINTOP,FOLLOW_POINTOP_in_pointExpr133); dbg.location(18,27);
					pushFollow(FOLLOW_atom_in_pointExpr135);
					atom();
					state._fsp--;

					}
					break;

				default :
					break loop7;
				}
			}
			} finally {dbg.exitSubRule(7);}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(18, 33);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "pointExpr");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "pointExpr"



	// $ANTLR start "atom"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:19:1: atom : ( intConst | ID );
	public final void atom() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "atom");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(19, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:19:6: ( intConst | ID )
			int alt8=2;
			try { dbg.enterDecision(8, decisionCanBacktrack[8]);

			int LA8_0 = input.LA(1);
			if ( (LA8_0==NUMBER) ) {
				alt8=1;
			}
			else if ( (LA8_0==ID) ) {
				alt8=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 8, 0, input);
				dbg.recognitionException(nvae);
				throw nvae;
			}

			} finally {dbg.exitDecision(8);}

			switch (alt8) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:19:8: intConst
					{
					dbg.location(19,8);
					pushFollow(FOLLOW_intConst_in_atom145);
					intConst();
					state._fsp--;

					}
					break;
				case 2 :
					dbg.enterAlt(2);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:20:4: ID
					{
					dbg.location(20,4);
					match(input,ID,FOLLOW_ID_in_atom150); 
					}
					break;

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(21, 1);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "atom");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "atom"



	// $ANTLR start "comparison"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:1: comparison : ( ID | constant ) RELOP ( ID | constant ) ;
	public final void comparison() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "comparison");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(25, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:11: ( ( ID | constant ) RELOP ( ID | constant ) )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:13: ( ID | constant ) RELOP ( ID | constant )
			{
			dbg.location(25,13);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:13: ( ID | constant )
			int alt9=2;
			try { dbg.enterSubRule(9);
			try { dbg.enterDecision(9, decisionCanBacktrack[9]);

			int LA9_0 = input.LA(1);
			if ( (LA9_0==ID) ) {
				alt9=1;
			}
			else if ( (LA9_0==BOOL||LA9_0==NUMBER||LA9_0==16) ) {
				alt9=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 9, 0, input);
				dbg.recognitionException(nvae);
				throw nvae;
			}

			} finally {dbg.exitDecision(9);}

			switch (alt9) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:14: ID
					{
					dbg.location(25,14);
					match(input,ID,FOLLOW_ID_in_comparison163); 
					}
					break;
				case 2 :
					dbg.enterAlt(2);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:17: constant
					{
					dbg.location(25,17);
					pushFollow(FOLLOW_constant_in_comparison165);
					constant();
					state._fsp--;

					}
					break;

			}
			} finally {dbg.exitSubRule(9);}
			dbg.location(25,27);
			match(input,RELOP,FOLLOW_RELOP_in_comparison168); dbg.location(25,33);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:33: ( ID | constant )
			int alt10=2;
			try { dbg.enterSubRule(10);
			try { dbg.enterDecision(10, decisionCanBacktrack[10]);

			int LA10_0 = input.LA(1);
			if ( (LA10_0==ID) ) {
				alt10=1;
			}
			else if ( (LA10_0==BOOL||LA10_0==NUMBER||LA10_0==16) ) {
				alt10=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 10, 0, input);
				dbg.recognitionException(nvae);
				throw nvae;
			}

			} finally {dbg.exitDecision(10);}

			switch (alt10) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:34: ID
					{
					dbg.location(25,34);
					match(input,ID,FOLLOW_ID_in_comparison171); 
					}
					break;
				case 2 :
					dbg.enterAlt(2);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:25:37: constant
					{
					dbg.location(25,37);
					pushFollow(FOLLOW_constant_in_comparison173);
					constant();
					state._fsp--;

					}
					break;

			}
			} finally {dbg.exitSubRule(10);}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(25, 46);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "comparison");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "comparison"



	// $ANTLR start "ifStat"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:27:1: ifStat : 'if' comparison 'then' statement ( 'else' statement )? 'fi' ;
	public final void ifStat() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "ifStat");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(27, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:27:8: ( 'if' comparison 'then' statement ( 'else' statement )? 'fi' )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:27:10: 'if' comparison 'then' statement ( 'else' statement )? 'fi'
			{
			dbg.location(27,10);
			match(input,26,FOLLOW_26_in_ifStat183); dbg.location(27,15);
			pushFollow(FOLLOW_comparison_in_ifStat185);
			comparison();
			state._fsp--;
			dbg.location(27,26);
			match(input,34,FOLLOW_34_in_ifStat187); dbg.location(27,33);
			pushFollow(FOLLOW_statement_in_ifStat189);
			statement();
			state._fsp--;
			dbg.location(27,43);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:27:43: ( 'else' statement )?
			int alt11=2;
			try { dbg.enterSubRule(11);
			try { dbg.enterDecision(11, decisionCanBacktrack[11]);

			int LA11_0 = input.LA(1);
			if ( (LA11_0==23) ) {
				alt11=1;
			}
			} finally {dbg.exitDecision(11);}

			switch (alt11) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:27:44: 'else' statement
					{
					dbg.location(27,44);
					match(input,23,FOLLOW_23_in_ifStat192); dbg.location(27,51);
					pushFollow(FOLLOW_statement_in_ifStat194);
					statement();
					state._fsp--;

					}
					break;

			}
			} finally {dbg.exitSubRule(11);}
			dbg.location(27,63);
			match(input,25,FOLLOW_25_in_ifStat198); 
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(27, 66);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "ifStat");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "ifStat"



	// $ANTLR start "whileStat"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:29:1: whileStat : 'while' comparison 'do' ( statement )* 'od' ;
	public final void whileStat() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "whileStat");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(29, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:29:11: ( 'while' comparison 'do' ( statement )* 'od' )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:29:12: 'while' comparison 'do' ( statement )* 'od'
			{
			dbg.location(29,12);
			match(input,35,FOLLOW_35_in_whileStat205); dbg.location(29,20);
			pushFollow(FOLLOW_comparison_in_whileStat207);
			comparison();
			state._fsp--;
			dbg.location(29,31);
			match(input,22,FOLLOW_22_in_whileStat209); dbg.location(29,36);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:29:36: ( statement )*
			try { dbg.enterSubRule(12);

			loop12:
			while (true) {
				int alt12=2;
				try { dbg.enterDecision(12, decisionCanBacktrack[12]);

				int LA12_0 = input.LA(1);
				if ( (LA12_0==ID||LA12_0==26||LA12_0==29||LA12_0==31||LA12_0==35) ) {
					alt12=1;
				}

				} finally {dbg.exitDecision(12);}

				switch (alt12) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:29:36: statement
					{
					dbg.location(29,36);
					pushFollow(FOLLOW_statement_in_whileStat211);
					statement();
					state._fsp--;

					}
					break;

				default :
					break loop12;
				}
			}
			} finally {dbg.exitSubRule(12);}
			dbg.location(29,47);
			match(input,28,FOLLOW_28_in_whileStat214); 
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(29, 50);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "whileStat");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "whileStat"



	// $ANTLR start "readStat"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:31:1: readStat : 'read' POPEN ID PCLOSED ;
	public final void readStat() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "readStat");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(31, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:31:10: ( 'read' POPEN ID PCLOSED )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:31:12: 'read' POPEN ID PCLOSED
			{
			dbg.location(31,12);
			match(input,31,FOLLOW_31_in_readStat222); dbg.location(31,20);
			match(input,POPEN,FOLLOW_POPEN_in_readStat225); dbg.location(31,26);
			match(input,ID,FOLLOW_ID_in_readStat227); dbg.location(31,29);
			match(input,PCLOSED,FOLLOW_PCLOSED_in_readStat229); 
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(31, 35);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "readStat");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "readStat"



	// $ANTLR start "printStat"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:33:1: printStat : 'println' POPEN ( ID | stringConst ) PCLOSED ;
	public final void printStat() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "printStat");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(33, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:33:11: ( 'println' POPEN ( ID | stringConst ) PCLOSED )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:33:13: 'println' POPEN ( ID | stringConst ) PCLOSED
			{
			dbg.location(33,13);
			match(input,29,FOLLOW_29_in_printStat237); dbg.location(33,23);
			match(input,POPEN,FOLLOW_POPEN_in_printStat239); dbg.location(33,29);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:33:29: ( ID | stringConst )
			int alt13=2;
			try { dbg.enterSubRule(13);
			try { dbg.enterDecision(13, decisionCanBacktrack[13]);

			int LA13_0 = input.LA(1);
			if ( (LA13_0==ID) ) {
				alt13=1;
			}
			else if ( (LA13_0==16) ) {
				alt13=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 13, 0, input);
				dbg.recognitionException(nvae);
				throw nvae;
			}

			} finally {dbg.exitDecision(13);}

			switch (alt13) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:33:30: ID
					{
					dbg.location(33,30);
					match(input,ID,FOLLOW_ID_in_printStat242); 
					}
					break;
				case 2 :
					dbg.enterAlt(2);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:33:33: stringConst
					{
					dbg.location(33,33);
					pushFollow(FOLLOW_stringConst_in_printStat244);
					stringConst();
					state._fsp--;

					}
					break;

			}
			} finally {dbg.exitSubRule(13);}
			dbg.location(33,46);
			match(input,PCLOSED,FOLLOW_PCLOSED_in_printStat247); 
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(33, 53);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "printStat");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "printStat"



	// $ANTLR start "intConst"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:37:1: intConst : ( NUMBER )+ ;
	public final void intConst() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "intConst");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(37, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:37:10: ( ( NUMBER )+ )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:37:12: ( NUMBER )+
			{
			dbg.location(37,12);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:37:12: ( NUMBER )+
			int cnt14=0;
			try { dbg.enterSubRule(14);

			loop14:
			while (true) {
				int alt14=2;
				try { dbg.enterDecision(14, decisionCanBacktrack[14]);

				int LA14_0 = input.LA(1);
				if ( (LA14_0==NUMBER) ) {
					alt14=1;
				}

				} finally {dbg.exitDecision(14);}

				switch (alt14) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:37:12: NUMBER
					{
					dbg.location(37,12);
					match(input,NUMBER,FOLLOW_NUMBER_in_intConst258); 
					}
					break;

				default :
					if ( cnt14 >= 1 ) break loop14;
					EarlyExitException eee = new EarlyExitException(14, input);
					dbg.recognitionException(eee);

					throw eee;
				}
				cnt14++;
			}
			} finally {dbg.exitSubRule(14);}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(37, 18);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "intConst");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "intConst"



	// $ANTLR start "stringConst"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:40:1: stringConst : '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"' ;
	public final void stringConst() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "stringConst");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(40, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:41:5: ( '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"' )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:41:8: '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"'
			{
			dbg.location(41,8);
			match(input,16,FOLLOW_16_in_stringConst273); dbg.location(41,12);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:41:12: ( ESC_SEQ |~ ( '\\\\' | '\"' ) )*
			try { dbg.enterSubRule(15);

			loop15:
			while (true) {
				int alt15=2;
				try { dbg.enterDecision(15, decisionCanBacktrack[15]);

				int LA15_0 = input.LA(1);
				if ( ((LA15_0 >= BOOL && LA15_0 <= SEMI)||(LA15_0 >= 17 && LA15_0 <= 18)||(LA15_0 >= 20 && LA15_0 <= 35)) ) {
					alt15=1;
				}

				} finally {dbg.exitDecision(15);}

				switch (alt15) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:
					{
					dbg.location(41,12);
					if ( (input.LA(1) >= BOOL && input.LA(1) <= SEMI)||(input.LA(1) >= 17 && input.LA(1) <= 18)||(input.LA(1) >= 20 && input.LA(1) <= 35) ) {
						input.consume();
						state.errorRecovery=false;
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						dbg.recognitionException(mse);
						throw mse;
					}
					}
					break;

				default :
					break loop15;
				}
			}
			} finally {dbg.exitSubRule(15);}
			dbg.location(41,39);
			match(input,16,FOLLOW_16_in_stringConst291); 
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(42, 4);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "stringConst");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "stringConst"



	// $ANTLR start "realConst"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:43:1: realConst : ( NUMBER )+ '.' ( NUMBER )* ;
	public final void realConst() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "realConst");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(43, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:44:5: ( ( NUMBER )+ '.' ( NUMBER )* )
			dbg.enterAlt(1);

			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:44:9: ( NUMBER )+ '.' ( NUMBER )*
			{
			dbg.location(44,9);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:44:9: ( NUMBER )+
			int cnt16=0;
			try { dbg.enterSubRule(16);

			loop16:
			while (true) {
				int alt16=2;
				try { dbg.enterDecision(16, decisionCanBacktrack[16]);

				int LA16_0 = input.LA(1);
				if ( (LA16_0==NUMBER) ) {
					alt16=1;
				}

				} finally {dbg.exitDecision(16);}

				switch (alt16) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:44:9: NUMBER
					{
					dbg.location(44,9);
					match(input,NUMBER,FOLLOW_NUMBER_in_realConst309); 
					}
					break;

				default :
					if ( cnt16 >= 1 ) break loop16;
					EarlyExitException eee = new EarlyExitException(16, input);
					dbg.recognitionException(eee);

					throw eee;
				}
				cnt16++;
			}
			} finally {dbg.exitSubRule(16);}
			dbg.location(44,17);
			match(input,18,FOLLOW_18_in_realConst312); dbg.location(44,21);
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:44:21: ( NUMBER )*
			try { dbg.enterSubRule(17);

			loop17:
			while (true) {
				int alt17=2;
				try { dbg.enterDecision(17, decisionCanBacktrack[17]);

				int LA17_0 = input.LA(1);
				if ( (LA17_0==NUMBER) ) {
					alt17=1;
				}

				} finally {dbg.exitDecision(17);}

				switch (alt17) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:44:21: NUMBER
					{
					dbg.location(44,21);
					match(input,NUMBER,FOLLOW_NUMBER_in_realConst314); 
					}
					break;

				default :
					break loop17;
				}
			}
			} finally {dbg.exitSubRule(17);}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(45, 4);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "realConst");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "realConst"



	// $ANTLR start "constant"
	// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:48:1: constant : ( stringConst | BOOL realConst | intConst );
	public final void constant() throws RecognitionException {
		try { dbg.enterRule(getGrammarFileName(), "constant");
		if ( getRuleLevel()==0 ) {dbg.commence();}
		incRuleLevel();
		dbg.location(48, 0);

		try {
			// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:48:9: ( stringConst | BOOL realConst | intConst )
			int alt18=3;
			try { dbg.enterDecision(18, decisionCanBacktrack[18]);

			switch ( input.LA(1) ) {
			case 16:
				{
				alt18=1;
				}
				break;
			case BOOL:
				{
				alt18=2;
				}
				break;
			case NUMBER:
				{
				alt18=3;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 18, 0, input);
				dbg.recognitionException(nvae);
				throw nvae;
			}
			} finally {dbg.exitDecision(18);}

			switch (alt18) {
				case 1 :
					dbg.enterAlt(1);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:48:11: stringConst
					{
					dbg.location(48,11);
					pushFollow(FOLLOW_stringConst_in_constant328);
					stringConst();
					state._fsp--;

					}
					break;
				case 2 :
					dbg.enterAlt(2);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:48:24: BOOL realConst
					{
					dbg.location(48,24);
					match(input,BOOL,FOLLOW_BOOL_in_constant331); dbg.location(48,29);
					pushFollow(FOLLOW_realConst_in_constant333);
					realConst();
					state._fsp--;

					}
					break;
				case 3 :
					dbg.enterAlt(3);

					// /Users/iamapo/Downloads/CI Praktikum 1/MiniP.g:48:39: intConst
					{
					dbg.location(48,39);
					pushFollow(FOLLOW_intConst_in_constant335);
					intConst();
					state._fsp--;

					}
					break;

			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		dbg.location(48, 48);

		}
		finally {
			dbg.exitRule(getGrammarFileName(), "constant");
			decRuleLevel();
			if ( getRuleLevel()==0 ) {dbg.terminate();}
		}

	}
	// $ANTLR end "constant"

	// Delegated rules


	protected DFA5 dfa5 = new DFA5(this);
	static final String DFA5_eotS =
		"\11\uffff";
	static final String DFA5_eofS =
		"\11\uffff";
	static final String DFA5_minS =
		"\1\4\2\10\1\4\2\uffff\1\4\1\10\1\uffff";
	static final String DFA5_maxS =
		"\1\20\3\43\2\uffff\2\43\1\uffff";
	static final String DFA5_acceptS =
		"\4\uffff\1\3\1\1\2\uffff\1\2";
	static final String DFA5_specialS =
		"\11\uffff}>";
	static final String[] DFA5_transitionS = {
			"\1\4\3\uffff\1\2\1\uffff\1\1\5\uffff\1\3",
			"\2\5\1\1\1\uffff\1\5\1\uffff\1\4\10\uffff\4\5\1\uffff\2\5\1\uffff\1"+
			"\5\3\uffff\1\5",
			"\2\5\2\uffff\1\5\1\uffff\1\4\10\uffff\4\5\1\uffff\2\5\1\uffff\1\5\3"+
			"\uffff\1\5",
			"\14\6\1\7\2\6\1\uffff\20\6",
			"",
			"",
			"\14\6\1\7\2\6\1\uffff\20\6",
			"\1\10\5\uffff\1\4\10\uffff\4\10\1\uffff\2\10\1\uffff\1\10\3\uffff\1"+
			"\10",
			""
	};

	static final short[] DFA5_eot = DFA.unpackEncodedString(DFA5_eotS);
	static final short[] DFA5_eof = DFA.unpackEncodedString(DFA5_eofS);
	static final char[] DFA5_min = DFA.unpackEncodedStringToUnsignedChars(DFA5_minS);
	static final char[] DFA5_max = DFA.unpackEncodedStringToUnsignedChars(DFA5_maxS);
	static final short[] DFA5_accept = DFA.unpackEncodedString(DFA5_acceptS);
	static final short[] DFA5_special = DFA.unpackEncodedString(DFA5_specialS);
	static final short[][] DFA5_transition;

	static {
		int numStates = DFA5_transitionS.length;
		DFA5_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA5_transition[i] = DFA.unpackEncodedString(DFA5_transitionS[i]);
		}
	}

	protected class DFA5 extends DFA {

		public DFA5(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 5;
			this.eot = DFA5_eot;
			this.eof = DFA5_eof;
			this.min = DFA5_min;
			this.max = DFA5_max;
			this.accept = DFA5_accept;
			this.special = DFA5_special;
			this.transition = DFA5_transition;
		}
		@Override
		public String getDescription() {
			return "16:22: ( arithExpr | stringConst | comparison )";
		}
		public void error(NoViableAltException nvae) {
			dbg.recognitionException(nvae);
		}
	}

	public static final BitSet FOLLOW_30_in_prog12 = new BitSet(new long[]{0x0000000308300000L});
	public static final BitSet FOLLOW_declaration_in_prog14 = new BitSet(new long[]{0x0000000308300000L});
	public static final BitSet FOLLOW_20_in_prog17 = new BitSet(new long[]{0x00000008A5000100L});
	public static final BitSet FOLLOW_statement_in_prog19 = new BitSet(new long[]{0x00000008A5000100L});
	public static final BitSet FOLLOW_24_in_prog22 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_set_in_declaration30 = new BitSet(new long[]{0x0000000000000100L});
	public static final BitSet FOLLOW_ID_in_declaration40 = new BitSet(new long[]{0x0000000000028000L});
	public static final BitSet FOLLOW_17_in_declaration42 = new BitSet(new long[]{0x0000000000000100L});
	public static final BitSet FOLLOW_ID_in_declaration43 = new BitSet(new long[]{0x0000000000028000L});
	public static final BitSet FOLLOW_SEMI_in_declaration47 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_assignment_in_statement54 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ifStat_in_statement60 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_whileStat_in_statement73 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_readStat_in_statement80 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_printStat_in_statement86 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ID_in_assignment97 = new BitSet(new long[]{0x0000000000000040L});
	public static final BitSet FOLLOW_DECLA_in_assignment99 = new BitSet(new long[]{0x0000000000010510L});
	public static final BitSet FOLLOW_arithExpr_in_assignment102 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_stringConst_in_assignment104 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_comparison_in_assignment106 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pointExpr_in_arithExpr114 = new BitSet(new long[]{0x0000000000000202L});
	public static final BitSet FOLLOW_LINEOP_in_arithExpr117 = new BitSet(new long[]{0x0000000000000500L});
	public static final BitSet FOLLOW_pointExpr_in_arithExpr119 = new BitSet(new long[]{0x0000000000000202L});
	public static final BitSet FOLLOW_atom_in_pointExpr130 = new BitSet(new long[]{0x0000000000001002L});
	public static final BitSet FOLLOW_POINTOP_in_pointExpr133 = new BitSet(new long[]{0x0000000000000500L});
	public static final BitSet FOLLOW_atom_in_pointExpr135 = new BitSet(new long[]{0x0000000000001002L});
	public static final BitSet FOLLOW_intConst_in_atom145 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ID_in_atom150 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ID_in_comparison163 = new BitSet(new long[]{0x0000000000004000L});
	public static final BitSet FOLLOW_constant_in_comparison165 = new BitSet(new long[]{0x0000000000004000L});
	public static final BitSet FOLLOW_RELOP_in_comparison168 = new BitSet(new long[]{0x0000000000010510L});
	public static final BitSet FOLLOW_ID_in_comparison171 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_constant_in_comparison173 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_26_in_ifStat183 = new BitSet(new long[]{0x0000000000010510L});
	public static final BitSet FOLLOW_comparison_in_ifStat185 = new BitSet(new long[]{0x0000000400000000L});
	public static final BitSet FOLLOW_34_in_ifStat187 = new BitSet(new long[]{0x00000008A4000100L});
	public static final BitSet FOLLOW_statement_in_ifStat189 = new BitSet(new long[]{0x0000000002800000L});
	public static final BitSet FOLLOW_23_in_ifStat192 = new BitSet(new long[]{0x00000008A4000100L});
	public static final BitSet FOLLOW_statement_in_ifStat194 = new BitSet(new long[]{0x0000000002000000L});
	public static final BitSet FOLLOW_25_in_ifStat198 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_35_in_whileStat205 = new BitSet(new long[]{0x0000000000010510L});
	public static final BitSet FOLLOW_comparison_in_whileStat207 = new BitSet(new long[]{0x0000000000400000L});
	public static final BitSet FOLLOW_22_in_whileStat209 = new BitSet(new long[]{0x00000008B4000100L});
	public static final BitSet FOLLOW_statement_in_whileStat211 = new BitSet(new long[]{0x00000008B4000100L});
	public static final BitSet FOLLOW_28_in_whileStat214 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_31_in_readStat222 = new BitSet(new long[]{0x0000000000002000L});
	public static final BitSet FOLLOW_POPEN_in_readStat225 = new BitSet(new long[]{0x0000000000000100L});
	public static final BitSet FOLLOW_ID_in_readStat227 = new BitSet(new long[]{0x0000000000000800L});
	public static final BitSet FOLLOW_PCLOSED_in_readStat229 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_29_in_printStat237 = new BitSet(new long[]{0x0000000000002000L});
	public static final BitSet FOLLOW_POPEN_in_printStat239 = new BitSet(new long[]{0x0000000000010100L});
	public static final BitSet FOLLOW_ID_in_printStat242 = new BitSet(new long[]{0x0000000000000800L});
	public static final BitSet FOLLOW_stringConst_in_printStat244 = new BitSet(new long[]{0x0000000000000800L});
	public static final BitSet FOLLOW_PCLOSED_in_printStat247 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_NUMBER_in_intConst258 = new BitSet(new long[]{0x0000000000000402L});
	public static final BitSet FOLLOW_16_in_stringConst273 = new BitSet(new long[]{0x0000000FFFF7FFF0L});
	public static final BitSet FOLLOW_16_in_stringConst291 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_NUMBER_in_realConst309 = new BitSet(new long[]{0x0000000000040400L});
	public static final BitSet FOLLOW_18_in_realConst312 = new BitSet(new long[]{0x0000000000000402L});
	public static final BitSet FOLLOW_NUMBER_in_realConst314 = new BitSet(new long[]{0x0000000000000402L});
	public static final BitSet FOLLOW_stringConst_in_constant328 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_BOOL_in_constant331 = new BitSet(new long[]{0x0000000000000400L});
	public static final BitSet FOLLOW_realConst_in_constant333 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_intConst_in_constant335 = new BitSet(new long[]{0x0000000000000002L});
}
